// type point = {
//   x: number,
//   y: number
// }
// function printCord(pt: point) {
//   console.log(pt.x, pt.y);
// }
// printCord({ x: 100, y: 200 })

import type { Type } from 'typescript';
import type { TeleportProps } from 'vue';


// type ID = number | string
// function getId(id: ID) {
//   console.log(id);
// }
// getId(1);

// type userInput = string
// function sanitizedInput(str: string): userInput {
//   return str.slice(0, 2)
// }
// let uI = sanitizedInput('hello')
// console.log(uI);
// uI = 'new Input'
// console.log(uI); 
// interface Point {
//   x: number,
//   y: number 
// }
// function getPoint(pt: Point) {
//   console.log(pt);
// }
// getPoint({
//   x: 100, y: 2000
// })


// interface Animal {
//   name: string
// }
// interface Bear extends Animal {
//   site: string
// }
// const bear: Bear = {
//   name: '小白',
//   site: '江苏'
// }
// console.log(bear.name);
// console.log(bear.site);

// type Animal = {
//   name: string
// }
// type Bear = Animal   {
//   site: string
// }
// const bear: Bear = {
//   site: '湖北', 
//   name: '小白'
// }
// console.log(bear);

// interface Myfriends {
//   name: string,
//   num: number
// }
// interface Myfriends {
//   sex: string
//   site: Array<string>
// }

// const person: Myfriends = {
//   name: 'lwx',
//   num: 100,
//   sex: '女',
//   site: ['湖北', '江苏']
// }
// console.log(person);
// const myCanvas = document.getElementById('id1') as HTMLCanvasElement
// const myCanvas2 = <HTMLCanvasElement>document.getElementById('id2')
// const x = ('hello' as unknown) as number
// console.log(x);

// let a: 'hello' = 'hello'
// console.log(a);
// function fruit(name: string, age?: '18' | '20' | 28) {
//   console.log(name, age);
// }
// fruit('apple', '18')
// fruit('apple111')
// fruit('balana', '20')

// function compare(a: number, b: number): -1 | 0 | 1 {
//   return a > b ? -1 : a = b ? 0 : -1
// }
// console.log(compare(11, 11));

// interface Options {
//   width: number
// }

// function getOption(val: Options | 'auto'): string {
//   return '123'
// }
// getOption({ width: 123 })


// function handleRequest(url: string, methods: 'get' | 'post' | 'guess') {
//   console.log(url, methods);
// }
// let reqMsg = {
//   url: "www.example.com111",
//   methods: 'get'
// } as const
// handleRequest(reqMsg.url, reqMsg.methods)

// let x: undefined= undefined
// let y: null = null
// function doSomething(x: string|null){
//   if(x === null){

//   }else{
//   }
// }

// const a: bigint = BigInt(100)
// const b: bigint = 100n
// console.log(a, b);

// const c = Symbol('name')
// const d = Symbol('name')
// if (c.description === d.description) {
//   console.log('ok!');
// } else {
//   console.log('rejected');
// }

// type Fish = {
//   name: string
//   swim: () => void
// }
// type Bird = {
//   name: string
//   fly: () => void
// }

// function isFish(pet: Fish | Bird): pet is Fish {
//   return (pet as Fish).swim !== undefined
// }
// function getSmall(): Fish | Bird {
//   let fish: Fish = {
//     name: 'sharkey',
//     swim: () => {
//       console.log('swim');
//     }
//   }
//   let bird: Bird = {
//     name: 'sparrow',
//     fly: () => {
//       console.log('fly');
//     }
//   }
//   return true ? bird : fish
// }

// let pet = getSmall()
// console.log(pet);
// console.log(isFish(pet));
// if (isFish(pet)) {
//   pet.swim()
// } else {
//   pet.fly()
// }

//函数类型表达式

// function greeter(fn: (a: string) => void) {
//   fn('hello, word')
// }
// function prt(s: string) {
//   console.log(s);
// }
// greeter(prt)
// 调用签名
// type DesFunction = {
//   description: string,
//   (someArg: number): boolean
// }
// function doSomething(fn: DesFunction) {
//   console.log(fn.description + ' returned ' + fn(6));
// }
// function fn1(n: number) {
//   // console.log(n);
//   return true
// }
// fn1.description = 'hello'
// doSomething(fn1)

// 构造签名
// console.log(Object.prototype.toString.call(undefined));
// console.log(typeof null);
// 两个值存在关系，有的关联就是泛型

// function firstEle<Type>(arr: Type[]): Type | undefined {
//   return arr[0]
// }
// let res = firstEle(['1', 'asds'])
// let res = firstEle(['0', 2])
// console.log(res);
// function map<Input, Output>(arr: Input[], func: (arg: Input) => Output): Output[] {
//   return arr.map(func)
// }

// function longest<Type extends { length: number }>(a: Type, b: Type) {
//   if (a.length >= b.length) {
//     return a
//   } else {
//     return b
//   }
// }

// function miniLength<Type extends { length: number }>(obj: Type, minimum: number): Type | { length: number } {
//   if (obj.length >= minimum) {
//     return obj
//   } else {
//     return { length: minimum }
//   }
// }
// function name<Type>(params1: Type[], params2: Type[]): Type[] {
//   return params1.concat(params2)
// }
// const arr = name([1, 2, 3], [1])
// console.log(arr);

// function f(params: number = 123.9900) {
//   console.log(params.toFixed());
// }
// f()
// function myForEach(arr: any[], callback: (arg: any, index?: number) => void) {
//   for (let i = 0; i < arr.length; i++) {
//     callback(arr[i], i)
//   }
// }
// myForEach([1, 2, 3], (a) => console.log(a)) 
// function fn(x: string): string
// function fn(x: boolean | string): boolean | string {
//   return true
// }
// interface SomeType {
//   readonly prop: string
// }
// function doSomething(obj: SomeType) {
//   obj.prop = 123
//   console.log(obj.prop);
// }
// doSomething({ prop: '123' })
// 索引签名
// interface StringArray {
//   [index: number]: string
// }
// const myArray: StringArray = ['a', 'b']
// const secondItem = myArray[0]
// console.log(secondItem);

// interface TestString {
//   [props: string]: number
// }
// const testString: TestString = {
//   x: 100,
//   y: 2000
// }
// console.log(testString);
// interface Colorful {
//   color: string
// }

// interface Circle {
//   radius: number
// }
// type ColorfulCircle = Colorful & Circle
// const cc: ColorfulCircle = {
//   color: 'red',
//   radius: 100
// }

// function draw(circle: ColorfulCircle) {
//   console.log(circle);
// }
// draw({ color: 'red', radius: 100 })

// 接口和交叉类型的区别


// interface Box {
//   contents: unknown
// }
// let x: Box = {
//   contents: 'hello!'
// }
// console.log((x.contents as string).toLowerCase());

// 泛型对象

// interface Box<T> {
//   contents: T
// }
// let box1: Box<number> = {
//   contents: 123
// }

// interface StringBox {
//   contents: string
// }
// let box2: StringBox = {
//   contents: '123'
// }
// console.log(box1, box2);


// function log<Type>(arg: Array<Type>): Type[] {
//   console.log(arg.length);
//   return arg
// }
// log([1, 2, 3])

// 泛型类型
// function identity<Type>(arg: Type): Type {
//   return arg
// }

// let myId: <T>(arg: T) => T= identity
// console.log(myId);
// let myId2: { <Type>(arg: Type): Type } = identity
// 类型约束
// interface Length {
//   length: number
// }
// function loggingIdentity<Type extends Length>(arg: Type): Type {
//   return arg
// }
// console.log(loggingIdentity('100'));

// 约束中使用类型参数
// function getProperty<Type, Key extends keyof Type>(obj: Type, key: Key) {
//   return obj[key]
// }

// let x = {
//   a: 1,
//   b: 2,
//   c: 3
// }

// getProperty(x, 'a')
// keyof操作符
// type Point = { x: number, y: number }
// type P = keyof Point
// const p1: P = 'x'
// 索引签名
// type Arrayish = {
//   [key: string]: boolean
// 键在运行时会被强制转换为字符串，数字键也会被隐式转换为字符串形式
// }
// type A = keyof Arrayish

// const a: A = true

// console.log({}.toString());
// typeof操作符
// let s = 123
// let n: typeof s = 100
// console.log(n);

// 索引访问类型
// type Person = {
//   age: number,
//   name: string
// }
// type val = 'age' | 'name'
// type Age = Person['age' | 'name']
// let age: Age = '123'
// type Age1 = Person[val]
// let age1: Age1 = '456t'
// console.log(age, age1);
// type ToArray<Type> = Type extends any ? Type[] : never
// type StrArr = ToArray<string | number>

let tuple: [number, string, boolean];
tuple = [1, '1', true]
console.log(tuple);
// 装饰器
